package com.example.okhttp;

import androidx.appcompat.app.AppCompatActivity;

import android.os.Bundle;
import android.util.Log;

import org.jetbrains.annotations.NotNull;

import java.io.IOException;

import okhttp3.Call;
import okhttp3.Callback;
import okhttp3.OkHttpClient;
import okhttp3.Request;
import okhttp3.Response;

import static android.provider.ContactsContract.CommonDataKinds.Website.URL;

public class MainActivity extends AppCompatActivity {
    private static final String TAG = "MainActivity";
    private String url = "";

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
//        okhttpUse();
        sendRequest();
    }

    private void sendRequest() {
        MNOkhttp.sendJsonRequest(null, url, ResponseClass.class, new IJsonDataListener<ResponseClass>() {
            @Override
            public void onSuccess(ResponseClass m) {
                Log.e(TAG, m.getError_code() + " " + m.getReason());
            }
        });
    }

    private void okhttpUse() {
        OkHttpClient client = new OkHttpClient.Builder().build();
        Request request = new Request.Builder().url("").build();

        /**
         * 第一条主线：请求发送到哪里去了  请求发送到两个队列中，
         *    1. 运行中队列 ：当运行中的队列数据小于64并且访问同一个目标机器的数量小于5，就会加入到此，否则加到2。请求最多是64个，同一个域名最多5个请求
         *    2. 等待中队列 ：
         *
         * 第二条主线：请求是怎么被处理的
         *    先被加入到运行队列中，然后丢入线程池，直接执行getResponseWithInterceptorChain()方法
         *    使用责任链设计模式来处理请求（控制流量和访问速度）
         *      1. 从客户端的角度出发，希望发送请求之后，中间的流量消耗更小，而且流量小，处理的效率会好一点
         *      2. 如果客户端过大，一下子发送的请求过多，成百上千甚至上千万的数量，会导致服务器的压力过大
         *      3. 设置责任链，特别是缓存这个关卡，可以通过缓存直接获得数据而不用经过服务器，减少服务器的压力
         *    在interceptors列表中添加责任点
         *      如果自己有设计了拦截器，那么一开始的时候添加的就是我们自定义的拦截器，再添加下面的5个数据
         *      1. 加入重试以及重定向的拦截器：处理请求的重试和重定向问题，会创建StreamAllocation对象，用来负责管理cookie的连接池（最多5个）
         *      2. 加入桥拦截器：用来配置http协议的header参数
         *      3. 加入缓存拦截器：缓存策略
         *      4. 加入连接拦截器：去得到reallySocket对象
         *      5. 再真正地去访问服务器：enqueue
         *      val response = getResponseWithInterceptorChain()
         *      signalledCallback = true
         *      responseCallback.onResponse(this@RealCall, response)
         *      当执行完上面的代码之后就执行完网络请求
         *
         * 第三条主线：请求是怎么被维护的
         *      每个请求被处理完之后，会重新回到队列中，看看队列中是否有待处理的数据
         *          有：直接交给线程池处理
         *
         */

        Call call = client.newCall(request);
        // 请求从这里进去的
        call.enqueue(new Callback() {
            @Override
            public void onFailure(@NotNull Call call, @NotNull IOException e) {
                System.out.println("请求失败");
            }

            @Override
            public void onResponse(@NotNull Call call, @NotNull Response response) throws IOException {
                String content = response.body().toString();
                System.out.println("请求成功：content " + content);
            }
        });
    }
}